{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-ef2fa5313ccf>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /home/gaara/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/gaara/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/gaara/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/gaara/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/gaara/.local/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets('./',one_hot =  True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))#生成一个对象图\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4,idx+1)#参数：行号、列号、子图编号\n",
    "    plt.axis('off')#不显示坐标\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个bool类型的变量用于表示当前网络是否正在训练。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，应为我们这里还没确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\",[None,784],name='x')\n",
    "y = tf.placeholder('float',[None,10],name='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "应为我们输入的图片展开后是一维向量，所以第一步就需要先把一维向量还原为二维的图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x,[-1,28,28,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来我们定义第一个卷积层，使用6个5x5的卷积核对输入数据进行卷积，padding方式选择valid，所以输入数据的宽高变为24x24，但是深度已经从原来的1变成了6。本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(x_image,6,[5,5],padding='VALID',activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来进行进行stride为2的最大池化，池化后，输出深度不变，但是长宽减半，所以输出变成了12x12，深度为6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1,[2,2],stride=[2,2],padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们定义第二个卷积层，使用16个5x5的卷积核对输入数据进行卷积，padding方式还是valid，输出8x8,深度为16，本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(S2,16,[5,5],padding='VALID',activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再进行一次stride为2的最大池化，输出为4x4，深度16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3,[2,2],stride=[2,2],padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据是3维的，这里做一个拉平操作，将3维数据展开到1维，然后送入两层全连接，全连接隐层中神经元个数分别为120，84。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat=tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(S4_flat,120,activation_fn=tf.nn.relu)\n",
    "    \n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5,84,activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅再训练的时候使用，验证的时候，需要关闭dropout，所以验证的时候keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob',dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6,keep_prob)\n",
    "    \n",
    "with tf.name_scope('fc3'):\n",
    "    logits=tf.contrib.slim.fully_connected(F6_drop,10,activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义loss和用于优化网络的优化器。loss计算使用了\n",
    "sparse_softmax_cross_entropy_with_logits,这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    试试看，增加减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-e868c9f7307a>:3: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'tatal_loss:0' shape=() dtype=string>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#定义了交叉熵损失函数，注意输入为  未经激活的上层输出\n",
    "cross_entropy_loss=tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=y))\n",
    "\n",
    "#获取L2正则项\n",
    "l2_loss=tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "#得到目标函数\n",
    "total_loss = cross_entropy_loss+7e-5*l2_loss\n",
    "\n",
    "\n",
    "#定义优化器.并进行损失函数最小值计算\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.3).minimize(total_loss)\n",
    "\n",
    "\n",
    "\n",
    "#保存log记录\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name,w)\n",
    "    \n",
    "tf.summary.scalar('cross_entropy_loss',cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss',l2_loss)\n",
    "tf.summary.scalar('tatal_loss',total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布，要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)#最终结果softmax激活输出\n",
    "correct_pred = tf.equal(tf.argmax(y,1),tf.argmax(logits,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred,tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#定义saver 用于保存或恢复训练的模型\n",
    "saver =tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.40143,the validation accuracy is 0.93\n",
      "after 200 training steps, the loss is 0.18221,the validation accuracy is 0.956\n",
      "after 300 training steps, the loss is 0.17592,the validation accuracy is 0.9722\n",
      "after 400 training steps, the loss is 0.179875,the validation accuracy is 0.9754\n",
      "after 500 training steps, the loss is 0.10619,the validation accuracy is 0.9774\n",
      "after 600 training steps, the loss is 0.0166702,the validation accuracy is 0.9784\n",
      "after 700 training steps, the loss is 0.0154294,the validation accuracy is 0.9796\n",
      "after 800 training steps, the loss is 0.110727,the validation accuracy is 0.98\n",
      "after 900 training steps, the loss is 0.0632406,the validation accuracy is 0.977\n",
      "after 1000 training steps, the loss is 0.146073,the validation accuracy is 0.9822\n",
      "the training is finish!\n",
      "the test accuracy is: 0.9839\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    writer = tf.summary.FileWriter('logs/',sess.graph)#用了这句，后面在tensorborad里就可以查看节点图了\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    #定义了验证集与测试集\n",
    "    validate_data = {\n",
    "        x:mnist.validation.images,\n",
    "        y:mnist.validation.labels,\n",
    "        keep_prob:1.0\n",
    "    }\n",
    "    test_data = {x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0}\n",
    "    \n",
    "    for i in range(trainig_step):\n",
    "        xs,ys=mnist.train.next_batch(batch_size)\n",
    "        _,loss,rs = sess.run([optimizer,cross_entropy_loss,merged],\n",
    "                            feed_dict={\n",
    "                                x:xs,\n",
    "                                y:ys,\n",
    "                                keep_prob:0.6\n",
    "                            })\n",
    "        writer.add_summary(rs,i)\n",
    "        \n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i>0 and i%100 ==0:\n",
    "            validate_accuracy=sess.run(accuracy,feed_dict=validate_data)\n",
    "            print(\n",
    "            'after %d training steps, the loss is %g,the validation accuracy is %g'%(i,loss,validate_accuracy))\n",
    "            \n",
    "            saver.save(sess,'./model.ckpt',global_step=i)#保存check point\n",
    "            \n",
    "    print('the training is finish!')\n",
    "     #最终的测试准确率\n",
    "    acc = sess.run(accuracy,feed_dict=test_data)\n",
    "    print('the test accuracy is:',acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')#获取之前存储的最新训练模型结果\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess,ckpt.model_checkpoint_path)\n",
    "        final_pred,acc = sess.run([pred,accuracy],\n",
    "                                 feed_dict={\n",
    "                                     x:mnist.test.images[:16],\n",
    "                                     y:mnist.test.labels[:16],\n",
    "                                     keep_prob:1.0\n",
    "                                 })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8,8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order =orders[idx,:][-1]\n",
    "            prob = final_pred[idx,:][order]\n",
    "            plt.subplot(4,4,idx+1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}:[{}-[{:.1f}%]]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]),order,prob*100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28,28)))\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 0, 5, 8, 1, 4, 3, 9, 2, 7],\n",
       "       [9, 5, 4, 7, 6, 8, 3, 0, 1, 2],\n",
       "       [5, 0, 3, 2, 9, 6, 4, 7, 8, 1],\n",
       "       [1, 5, 4, 7, 3, 2, 9, 6, 8, 0],\n",
       "       [0, 3, 2, 1, 7, 5, 8, 6, 9, 4],\n",
       "       [5, 0, 3, 2, 6, 9, 4, 7, 8, 1],\n",
       "       [0, 5, 2, 3, 6, 1, 7, 9, 8, 4],\n",
       "       [2, 6, 1, 0, 7, 5, 3, 8, 4, 9],\n",
       "       [2, 7, 1, 4, 3, 0, 9, 6, 8, 5],\n",
       "       [6, 2, 1, 0, 3, 5, 8, 4, 7, 9],\n",
       "       [1, 4, 5, 7, 3, 9, 8, 2, 6, 0],\n",
       "       [3, 1, 7, 2, 9, 4, 5, 0, 8, 6],\n",
       "       [2, 6, 1, 0, 3, 7, 5, 8, 4, 9],\n",
       "       [1, 4, 5, 7, 2, 3, 6, 9, 8, 0],\n",
       "       [0, 5, 3, 2, 7, 9, 6, 4, 8, 1],\n",
       "       [4, 2, 7, 1, 0, 8, 6, 9, 3, 5]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders[1][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6.8805773e-12, 8.1522161e-10, 1.6644087e-07, 2.7288516e-08,\n",
       "        2.0232354e-08, 5.5979926e-11, 7.7167387e-15, 9.9999964e-01,\n",
       "        3.0264194e-10, 1.4648681e-07],\n",
       "       [4.9454695e-07, 2.1725998e-06, 9.9999714e-01, 1.6848770e-07,\n",
       "        1.6933790e-09, 2.4568009e-11, 1.5521170e-08, 1.8966790e-09,\n",
       "        2.2674971e-08, 3.7567120e-12],\n",
       "       [4.5668626e-06, 9.9949670e-01, 2.7787541e-05, 7.4854797e-06,\n",
       "        8.0022124e-05, 3.2726161e-06, 3.6673435e-05, 8.5488049e-05,\n",
       "        2.2150368e-04, 3.6612175e-05],\n",
       "       [9.9997962e-01, 9.5208674e-10, 6.3369907e-07, 2.9723915e-07,\n",
       "        4.8902731e-08, 3.6498140e-08, 7.9137826e-06, 7.0481207e-08,\n",
       "        8.2386505e-06, 3.2445930e-06],\n",
       "       [2.1890884e-08, 1.7284142e-07, 9.9960928e-08, 8.9314845e-08,\n",
       "        9.9993896e-01, 2.3959538e-07, 4.6745441e-07, 2.1321927e-07,\n",
       "        4.0366055e-07, 5.9304279e-05],\n",
       "       [1.0216957e-06, 9.9979919e-01, 6.2896388e-06, 2.3315627e-06,\n",
       "        4.3002216e-05, 4.3195189e-07, 6.8621434e-06, 4.4221688e-05,\n",
       "        7.8422156e-05, 1.8089429e-05],\n",
       "       [7.9469935e-08, 7.7887271e-05, 4.8510669e-06, 7.3742431e-06,\n",
       "        9.9494499e-01, 3.4715661e-06, 7.4608765e-06, 2.7258511e-04,\n",
       "        4.0627928e-03, 6.1848329e-04],\n",
       "       [5.9508156e-06, 3.7392560e-06, 4.5806786e-07, 2.5518949e-04,\n",
       "        7.8691356e-04, 1.5874283e-04, 9.2055546e-07, 2.5707559e-05,\n",
       "        3.0794181e-04, 9.9845445e-01],\n",
       "       [4.6350717e-04, 3.5131547e-05, 1.0877268e-05, 1.2481790e-04,\n",
       "        8.6293512e-05, 7.6818854e-01, 1.8563483e-02, 3.3575612e-05,\n",
       "        2.0232558e-01, 1.0168083e-02],\n",
       "       [2.7094291e-07, 4.4142730e-08, 1.0228214e-08, 3.1552688e-06,\n",
       "        2.8673170e-05, 3.2770420e-06, 4.5395563e-09, 2.2967398e-04,\n",
       "        2.3446635e-05, 9.9971133e-01],\n",
       "       [9.9999380e-01, 8.9477328e-11, 2.1083613e-06, 5.1583200e-08,\n",
       "        2.5041811e-09, 1.4248005e-08, 2.8566660e-06, 1.7721886e-08,\n",
       "        9.4881955e-07, 1.6881314e-07],\n",
       "       [7.8388457e-06, 2.1623854e-09, 4.1250434e-09, 1.3046023e-09,\n",
       "        4.5207113e-07, 4.9099222e-06, 9.9993062e-01, 2.9340397e-09,\n",
       "        5.5967907e-05, 1.5465595e-07],\n",
       "       [8.3567393e-09, 1.6181162e-09, 3.5003764e-10, 3.6696525e-07,\n",
       "        2.9536417e-05, 8.3990614e-07, 7.4565459e-10, 8.2252109e-07,\n",
       "        1.4960372e-06, 9.9996686e-01],\n",
       "       [9.9988520e-01, 1.3719819e-09, 9.2577574e-07, 1.5399188e-06,\n",
       "        3.0727566e-08, 1.1176442e-07, 3.4739130e-06, 2.2614552e-07,\n",
       "        9.4243122e-05, 1.4195688e-05],\n",
       "       [3.4780978e-08, 9.9997818e-01, 4.2323404e-07, 3.0695614e-07,\n",
       "        6.8528484e-06, 8.3380982e-08, 2.5658487e-06, 1.1612688e-06,\n",
       "        9.1249876e-06, 1.1895083e-06],\n",
       "       [1.2718927e-04, 4.1776580e-05, 4.6494401e-06, 3.3094045e-03,\n",
       "        3.7243226e-06, 9.9318552e-01, 6.8748754e-04, 3.2906817e-05,\n",
       "        6.0310186e-04, 2.0041193e-03]], dtype=float32)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
